home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / yase.arc / FILEPRIM.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-12-13  |  10.0 KB  |  285 lines
  1. ******************************************************************
  2. * COPYRIGHT (C) 1986 by Donald Krantz and James Stanley
  3. * - Note: This is a real, live, actual, registered copyright,
  4. *   and should be treated as such. This source code is from
  5. *   the book "68000 Assembly Language", Krantz and Stanley,
  6. *   Addison-Wesley Publishing Company, Reading, MA, 1986.
  7. * 
  8. *   Permission granted by the authors for non-commercial use
  9. *   in programs released to the public domain, as long as this
  10. *   copyright notice remains attached and visible.
  11. *
  12. ***************************************************************
  13. * File Primitive Operations - CP/M-68K
  14. *
  15. * All routines interface to CP/M-68K files. FCB and FILE block
  16. * definitions are contained in FCB.H.
  17.  
  18. #fcb.h
  19.     .xdef    open,close,fgetc,fputc
  20.  
  21. * Routines:    OPEN    Opens a file for input or output.
  22. *         Entry: P0.L points to FILE block. P1.L points to
  23. *                null-terminated name string. P2.W = 0
  24. *            for "File must Exist", nonzero
  25. *            for "Create new and erase old".
  26. *         Exit:  File opened or D0.W = -1
  27. *
  28. *        CLOSE    Closes a file. Flushes current buffer
  29. *            if dirty. 
  30. *         Entry:    P0.L points to FILE block.
  31. *         Exit:    File closed or D0.W = -1
  32. *
  33. *        FGETC    Returns next char from file.
  34. *         Entry: P0.L points to FILE block.
  35. *         Exit:    D0.W = char or -1 on error.
  36. *
  37. *        FPUTC    Writes next char to file.
  38. *         Entry:    P0.L points to FILE block.
  39. *            P1.W is the char to write.
  40. *         Exit:    D0.W = 0 for success, -1 on failure.
  41. *
  42. *****************************************************************
  43. open:
  44.     link    a6,#0        * Set stack frame
  45.     movem.l    d1/d2/a0/a1/a2,-(a7)
  46.     bsr    parse_name    * Parses filename to FCB
  47.     tst.w    d0        * Check return from PARSE_NAME
  48.     bmi    exit_open    * Exit on error
  49.     bsr    fillfcb        * Set balance of FCB
  50.     move.l    8(a6),d1    * Get FCB addr for CP/M calls
  51.     tst.w    16(a6)        * Open new file or old?
  52.     bne    make_new    * Make new file, erase any old.    
  53. must_exist:    
  54.     move.w    #$000f,d0    * CP/M OPEN FILE Function Code
  55.     trap    #2        * Call CP/M - Open existing file
  56.     bra    exit_open    * Exit
  57. make_new:
  58.     move.w    #$0013,d0    * CP/M DELETE FILE Function code
  59.     trap    #2        * Call CP/M - delete any old file
  60.     move.w    #$0016,d0    * CP/M MAKE FILE Function code
  61.     trap    #2        * Call CP/M - attempt create
  62. exit_open:
  63.     ext.w    d0        * Convert CP/M return to our type
  64.     movem.l    (a7)+,d1/d2/a0/a1/a2
  65.     unlk    a6        * Restore caller's stack frame
  66.     rts
  67. *
  68. *****************************************************************
  69. * PARSE_NAME parses a C name string into CP/M-68K FCB. Uses
  70. * caller's stack frame. Consider this a local procedure to OPEN.
  71. parse_name:
  72.     move.l    8(a6),a0    * Pick up FCB address
  73.     move.l    12(a6),a1    * Pick up name string
  74.     move.w    #10,d0        * Loop counter for blank filling
  75. blank_loop:
  76.     move.b    #' ',1(a0,d0.w)    * Blank fill name "backwards"
  77.     dbra    d0,blank_loop    * Continue for 11 bytes
  78. *
  79.     cmp.b    #':',1(a1)    * Check for drivespec
  80.     bne    no_drive    * No drivespec, jump over
  81.     move.b    (a1),(a0)    * Transfer drivespec
  82.     and.b    #$0f,(a0)+    * Make into 0..16 drivecode
  83.     addq.l    #2,a1        * Put pointer past drivespec
  84.     bra    name_xfr    * Go transfer name
  85. no_drive:
  86.     clr.b    (a0)+        * Set default drivecode    
  87. name_xfr:
  88.     move.w    #7,d0        * Start with filename part
  89. name_loop:
  90.     move.b    (a1)+,d2    * Pickup name character
  91.     beq    parse_chk    * Found a terminal null...
  92.     cmp.b    #'.',d2        * Look for delimiter
  93.     beq    ext_xfr        * Parse extension
  94.     bsr    check        * Make uppercase & screen chars
  95.     tst.b    d1        * D1 = -1 for illegal character
  96.     bmi    parse_err    * Exit if CHECK found error
  97.     move.b    d2,(a0)+    * Put char in FCB
  98.     dbra    d0,name_loop    * Try again
  99. * If we're here, 8 filename chars were found. Skip period.
  100.     move.b    (a1)+,d2    * Move pointer and check char
  101.     cmp.b    #'.',d2        * Double check for period
  102.     beq    ext_xfr        * OK, let's continue  
  103.     bra    parse_err    * Badly formed name string.
  104. ext_xfr:
  105.     move.l    8(a6),a0    * Re-sync FCB pointer
  106.     adda    #type,a0    * Point at TYPE field
  107.     move.w    #2,d0        * Three chars only for filetype
  108. ext_loop:
  109.     move.b    (a1)+,d2    * Pickup filetype char
  110.     beq    parse_chk    * Found terminal null...
  111.     bsr    check        * Make uppercase and screen chars
  112.     tst.b    d1        * Look for error return
  113.     bmi    parse_err    * Exit if CHECK found error.
  114.     move.b    d2,(a0)+    * Put filetype char into FCB
  115.     dbra    d0,ext_loop    * Go for next
  116. * If we're here, 3 filetype chars were found. Check for null.
  117.     tst.b    (a1)        * Is it null?
  118.     bne    parse_err    * No, return error
  119. parse_chk:
  120.     move.l    8(a6),a0    * Get FCB base addr again
  121.     cmp.b    #' ',name(a0)    * At least one name char?
  122.     beq    parse_err    * Nope, return error.
  123.     clr.w    d0        * "Good" return code
  124.     rts
  125. parse_err:
  126.     move.w    #-1,d0        * "Bad" return code
  127.     rts
  128. *
  129. *****************************************************************
  130. * FILLFCB zeros the non-name portion of the FCB. Local to OPEN.
  131. fillfcb:
  132.     move.l    8(a6),a0    * Load FCB base address
  133.     adda    #extent,a0    * Index past name portion
  134.     move.w    #dma_buf-extent-1,d0    * Loop count
  135. fill_loop:
  136.     clr.b    (a0)+        * Load zeros in all FILE fields
  137.     dbra    d0,fill_loop    * Continue for all bytes in FILE
  138.     tst.w    16(a6)        * Is this a write?
  139.     bne    fill_exit    * Yes, CURCHR is ok as zero.
  140.     move.l    8(a6),a0    * Get FCB address again.
  141.     move.w    #128,curchr(a0)    * Mark as "Need to read"
  142. fill_exit:
  143.     rts
  144. *
  145. *****************************************************************
  146. * CHECK converts lowercase to uppercase and screens chars CP/M
  147. * considers illegal name characters.
  148. check:
  149.     cmp.b    #'a',d2        * Check for lowercase first.
  150.     blt    not_lower    * It's less than 'a'
  151.     cmp.b    #'z',d2        * Less than 'z'?
  152.     bgt    not_lower    * It's greater than 'z'
  153.     and.b    #$5f,d2        * Makes D2.B uppercase
  154. not_lower:
  155.     move.w    #18,d1        * 19 illegal name chars
  156.     lea    bad_chars,a2    * Get name array base
  157. chk_loop:
  158.     cmp.b    (a2)+,d2    * Test for bad char
  159.     beq    chk_err        * Bad char, return error
  160.     dbra    d1,chk_loop    * Keep trying.
  161.     clr.w    d1        * "Good" error return
  162.     rts            * "Good" exit
  163. chk_err:
  164.     move.w    #-1,d1        * "Bad" error return
  165.     rts            * "Bad" exit
  166. bad_chars:
  167.     dc.b    '.:[]()<>=*&,!|?/;+-'
  168.     even            * Force alignment
  169. *
  170. *****************************************************************
  171. * CLOSE    Closes a file. Flushes current buffer if dirty. 
  172. close:
  173.     link    a6,#0        * Setup stack frame
  174.     movem.l    d1/a0/a1,-(a7)    * Save caller's registers
  175.     move.l    8(a6),a0    * Pick up FCB base address
  176.     bsr    put_eof        * Add ASCII EOF (^Z)
  177.     bmi    exit_close    * Branch if write failed
  178.     move.l    d1,a0        * Setup CP/M parameter
  179.     move.w    #$0010,d0    * CP/M CLOSE FILE function code
  180.     trap    #2        * Close the file
  181. exit_close:
  182.     ext.w    d0        * Convert CP/M return to our type
  183.     movem.l    (a7)+,d1/a0/a1     * Restore caller's registers
  184.     unlk    a6        * Restore caller's stack frame
  185.     rts
  186. *
  187. *****************************************************************
  188. * PUT_EOF fills the end of the current DMA buffer with ^Z
  189. put_eof:
  190.     cmp.w    #128,curchr(a0) * Check if we need to add another
  191.     bne    do_rest        * record with EOFs. (jump on NO)
  192.     tst.w    dirty(a0)    * look for empty record
  193.     beq    do_rest        * jump if this record empty
  194.     bsr    write_buf    * Flush current record
  195. do_rest:
  196.     move.w    #127,d0        * Set up number of chars to fill
  197.     sub.w    curchr(a0),d0    * less current character count
  198.     adda    curchr(a0),a0    * Get address of first fill char
  199.     adda    #dma_buf,a0    * Need this too.
  200. put_loop:
  201.     move.b    #$1a,(a0)+    * Insert character
  202.     dbra    d0,put_loop    * Continue through buffer
  203.     bsr    write_buf    * Flush filled record
  204.     rts
  205. *
  206. *****************************************************************
  207. * FPUTC puts a character to a disk file.
  208. fputc:
  209.     link    a6,#0        * Freeze stack frame
  210.     movem.l    a0/d1,-(a7)    * Save caller's registers
  211.     move.l    8(a6),a0    * Grab FCB
  212.     cmp.w    #128,curchr(a0)    * Check for record full
  213.     bne    just_put    * Nope, we're OK.
  214.     bsr    write_buf    * Flush current record
  215. just_put:
  216.     move.w    curchr(a0),d0    * Get current char count
  217.     addq.w    #1,curchr(a0)    * Bump counter
  218.     move.w    #-1,dirty(a0)    * Make dirty
  219.     move.b    13(a6),dma_buf(a0,d0.w)    * Save character
  220.     movem.l    (a7)+,a0/d1    * Restore caller's registers
  221.     unlk    a6        * Restore caller's stack frame
  222.     rts
  223. *
  224. *****************************************************************
  225. * WRITE_BUF writes the current record to disk and resets FILE buf
  226. write_buf:
  227.     move.l    8(a6),d1    * Get FCB base address
  228.     add.l    #dma_buf,d1    * Compute DMA buffer address
  229.     move.w    #$001a,d0    * CP/M SET DMA ADDRESS Function
  230.     trap    #2        * Setup DMA address
  231.     move.l    8(a6),a0    * Get FCB base address 
  232.     clr.w    dirty(a0)    * Mark dirty flag as "clean"
  233.     clr.w    curchr(a0)    * Set current char pointer to 0
  234.     move.l    a0,d1        * Get FCB address for CP/M
  235.     move.w    #$0015,d0    * CP/M WRITE SEQUENTIAL Function
  236.     trap    #2        * Write record
  237.     ext.w    d0        * Convert CP/M return to our type
  238.     rts
  239. *
  240. *****************************************************************
  241. * FGETC returns the next character from a file.
  242. fgetc:
  243.     link    a6,#0        * Establish stack frame
  244.     movem.l    d1/a0,-(a7)    * Save caller's registers
  245.     move.l    8(a6),a0    * Get FCB address
  246.     cmp.w    #128,curchr(a0)    * Do we need to read a record?
  247.     blt    no_read        * No, just get character
  248.     bsr    get_rec        * Read a record
  249.     tst.w    d0        * Was there an error?
  250.     bmi    fget_err    * Yes, return error to caller
  251. no_read:
  252.     move.w    curchr(a0),d0    * Get current character counter
  253.     addq.w    #1,curchr(a0)    * Increment current char count
  254.     move.b    dma_buf(a0,d0.w),d0 * Load next character
  255.     cmp.b    #$1a,d0        * Is it EOF?
  256.     beq    fget_err    * Yes, return error.
  257.     ext.w    d0        * Make into type "int".
  258.     bra    fget_exit    * And return...
  259. fget_err:
  260.     move.w    #-1,d0        * Indicate error
  261. fget_exit:
  262.     movem.l    (a7)+,d1/a0    * Restore caller's registers
  263.     unlk    a6        * Restore caller's stack frame
  264.     rts
  265. *
  266. *****************************************************************
  267. * GET_REC - reads next record sequentially. Local to FGETx.
  268. get_rec:
  269.     move.l    a0,d1        * Get FCB base address for CP/M
  270.     add.l    #dma_buf,d1    * Compute DMA buffer address
  271.     move.w    #$001a,d0    * CP/M SET DMA ADDRESS Function
  272.     trap    #2        * Setup DMA address
  273.     move.l    a0,d1        * Get FCB base address for CP/M
  274.     move.w    #$0014,d0    * CP/M READ SEQUENTIAL function
  275.     trap    #2        * Get the record
  276.     clr.w    dirty(a0)    * Mark record as "Clean"
  277.     clr.w    curchr(a0)    * Reset character counter
  278.     tst.b    d0        * Look at return code
  279.     bne    grec_err    * Returned an error...
  280.     rts            * Return success
  281. grec_err:
  282.     move.w    #-1,d0        * Load error return
  283.     rts            * Return error
  284.     end
  285.